#include <iostream>
#include <algorithm>
#include <iterator>
#include <string>
#include <stdexcept>

namespace myvector

{

    

  template<class T>

  class vector

  {

  public:

    // Vector的迭代器是一个原生指针

    typedef T* iterator;

    typedef const T* const_iterator;

    iterator begin(){return _start;} //指向第一个元素

    iterator end(){return _finish;} //指向最后一个元素的下一个位置

    const_iterator cbegin() const{ return _start;} //指向第一个元素

    const_iterator cend() const{ return _finish;} //指向最后一个元素的下一个位置



    // 构造函数
    

    vector()=default;

    vector(int n, const T& value = T())
    {
        _start = new T[n]; //分配内存
        _finish = _start + n; //指向最后一个元素的下一个位置
        _endOfStorage = _start + n; //指向存储容量的尾
        for (int i = 0; i < n; ++i) {
            _start[i] = value; //初始化元素
        }
    }

    //迭代器范围构造函数：用输入迭代器的范围初始化。
    template<class InputIterator>

    vector(InputIterator first, InputIterator last)
    {


        size_t n = last - first; //计算元素个数
        _start = new T[n]; //分配内存
        _finish = _start + n; //指向最后一个元素的下一个位置
        _endOfStorage = _start + n; //指向存储容量的尾
        for (size_t i = 0; i < n; ++i) {
            _start[i] = *(first + i); //初始化元素
        }
    }
    //拷贝构造函数
    vector(const vector<T>& v)
    {
        size_t n = v.size(); //计算元素个数
        _start = new T[n]; //分配内存
        _finish = _start + n; //指向最后一个元素的下一个位置
        _endOfStorage = _start + n; //指向存储容量的尾
        for (size_t i = 0; i < n; ++i) {
            _start[i] = v._start[i]; //初始化元素
        }
    }
    //赋值运算符重载
    //注意：这里使用了拷贝交换的技术，避免了内存泄漏和异常安全问题
    vector<T>& operator= (vector<T> v)  // 注意这里是传值，会生成一个临时副本
    {
        swap(v);     // 直接与临时副本交换
        return *this;
    }
    // vector<T>& operator= (const vector<T>& v)
    // {
    //     if(this!=&v)
    //     {
    //         vector tmp(v);
    //         swap(tmp); //tmp出作用域后析构，释放内存，避免手动释放原来的内存
           
    //     } return *this; //返回当前对象的引用;
    // }
   
    ~vector()
    {
        delete[] _start; //释放内存
        _start = nullptr; //指针置空
        _finish = nullptr; //指针置空
        _endOfStorage = nullptr; //指针置空
    }

    // capacity

    size_t size() const 
    {
        return _finish - _start; //计算元素个数
    }

    size_t capacity() const
    {
        return _endOfStorage - _start; //计算存储容量
    }

    void reserve(size_t n)
    {
        if (n > capacity()) { //如果需要扩容
            iterator newStart = new T[n]; //分配新的内存
            size_t size = this->size(); //计算元素个数
            for (size_t i = 0; i < size; ++i) {
                newStart[i] = _start[i]; //拷贝元素
            }
            delete[] _start; //释放原来的内存
            _start = newStart; //指向新的内存
            _finish = _start + size; //指向最后一个元素的下一个位置
            _endOfStorage = _start + n; //指向存储容量的尾
        }
    }

    void resize(size_t n, const T& value = T())
    {
        if(n==size()) return;
        if(n<size())
        {
            _finish=_start+n; //指向最后一个元素的下一个位置
        }
        else
        {
            reserve(n); //扩容
            for(size_t i=size();i<n;i++)
            {
                _start[i]=value; //初始化元素
            }
            _finish=_start+n; //指向最后一个元素的下一个位置
        }

    }



    ///////////////access///////////////////////////////

    T& operator[](size_t pos)
    {
        return _start[pos]; //返回元素
    }

    const T& operator[](size_t pos)const
    {
        return _start[pos]; //返回元素
    }
    // at()成员函数 - 带边界检查
    T& at(size_t pos) {
        if (pos >= size()) {
            throw std::out_of_range("vector subscript out of range");
        }
        return _start[pos];
    }
    
    const T& at(size_t pos) const {
        if (pos >= size()) {
            throw std::out_of_range("vector subscript out of range");
        }
        return _start[pos];
    }


    ///////////////modify/////////////////////////////

    void push_back(const T& x)
    {
        if (_finish == _endOfStorage) { //如果没有空间了
            reserve(size() == 0 ? 4 : size() * 2); //扩容
        }
        *_finish = x; //添加元素
        ++_finish; //指向下一个位置
    }

    void pop_back()
    {
        if (_finish != _start) { //如果有元素
            --_finish; //指向最后一个元素的下一个位置
        }
    }

    void swap(vector<T>& v)
    {
        std::swap(_start, v._start); //交换指针
        std::swap(_finish, v._finish); //交换指针
        std::swap(_endOfStorage, v._endOfStorage); //交换指针
    }

    iterator insert(iterator pos, const T& x)
    {
        if(pos < _start || pos > _finish) return nullptr; //检查位置是否合法
        if(size()+1>capacity()) //如果没有空间了
        {
            reserve(size() == 0 ? 4 : size() * 2); //扩容
        }
        for(iterator it=_finish;it>pos;--it) //从后往前移动元素
        {
            *it=*(it-1); //移动元素
        }
        *pos=x; //插入元素
        ++_finish; //指向最后一个元素的下一个位置
        return pos; //返回插入位置
    }

    iterator erase(iterator pos)
    {
        if(pos<_start || pos>=_finish) return nullptr; //检查位置是否合法
        for(iterator it=pos;it<_finish-1;++it) //从前往后移动元素
        {
            *it=*(it+1); //移动元素
        }
        --_finish; //指向最后一个元素的下一个位置
        return pos; //返回删除位置
    }

  private:

    iterator _start=nullptr; // 指向数据块的开始

    iterator _finish=nullptr; // 指向有效数据的尾

    iterator _endOfStorage=nullptr; // 指向存储容量的尾

  };

}




int main()
{
    myvector::vector<int> v1(5, 1); //初始化5个元素，值为1
    myvector::vector<int> v2(v1); //拷贝构造函数
    myvector::vector<int> v3; //默认构造函数
    v3=v1; //赋值运算符重载
    v3.push_back(2); //添加元素
    v3.pop_back(); //删除元素
    v3.insert(v3.begin(), 3); //插入元素
    v3.erase(v3.begin()); //删除元素
    return 0;

}


